home *** CD-ROM | disk | FTP | other *** search
/ Aminet 38 / Aminet 38 (2000)(Schatztruhe)[!][Aug 2000].iso / Aminet / dev / c / CLib-SDI.lha / CLib-SDI / include2 / inline / exec.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-06-25  |  14.4 KB  |  485 lines
  1. #ifndef _INLINE_EXEC_H
  2. #define _INLINE_EXEC_H
  3.  
  4. #ifndef __INLINE_MACROS_H
  5. #include <inline/macros.h>
  6. #endif
  7.  
  8. #ifndef EXEC_BASE_NAME
  9. #define EXEC_BASE_NAME SysBase
  10. #endif
  11.  
  12. #define Supervisor(userFunction) \
  13.     LP1A5FP(0x1E, ULONG, Supervisor, __fpt, userFunction, d7, \
  14.     , EXEC_BASE_NAME, ULONG (*__fpt)())
  15.  
  16. #define InitCode(startClass, version) \
  17.     LP2NR(0x48, InitCode, ULONG, startClass, d0, ULONG, version, d1, \
  18.     , EXEC_BASE_NAME)
  19.  
  20. #define InitStruct(initTable, memory, size) \
  21.     LP3NR(0x4E, InitStruct, CONST APTR, initTable, a1, APTR, memory, a2, ULONG, size, d0, \
  22.     , EXEC_BASE_NAME)
  23.  
  24. #define MakeLibrary(funcInit, structInit, libInit, dataSize, segList) \
  25.     LP5FP(0x54, struct Library *, MakeLibrary, CONST APTR, funcInit, a0, CONST APTR, structInit, a1, __fpt, libInit, a2, ULONG, dataSize, d0, ULONG, segList, d1, \
  26.     , EXEC_BASE_NAME, ULONG (*__fpt)())
  27.  
  28. #define MakeFunctions(target, functionArray, funcDispBase) \
  29.     LP3NR(0x5A, MakeFunctions, APTR, target, a0, CONST APTR, functionArray, a1, ULONG, funcDispBase, a2, \
  30.     , EXEC_BASE_NAME)
  31.  
  32. #define FindResident(name) \
  33.     LP1(0x60, struct Resident *, FindResident, CONST_STRPTR, name, a1, \
  34.     , EXEC_BASE_NAME)
  35.  
  36. #define InitResident(resident, segList) \
  37.     LP2(0x66, APTR, InitResident, CONST struct Resident *, resident, a1, ULONG, segList, d1, \
  38.     , EXEC_BASE_NAME)
  39.  
  40. #define Alert(alertNum) \
  41.     LP1NR(0x6C, Alert, ULONG, alertNum, d7, \
  42.     , EXEC_BASE_NAME)
  43.  
  44. #define Debug(flags) \
  45.     LP1NR(0x72, Debug, ULONG, flags, d0, \
  46.     , EXEC_BASE_NAME)
  47.  
  48. #define Disable() \
  49.     LP0NR(0x78, Disable, \
  50.     , EXEC_BASE_NAME)
  51.  
  52. #define Enable() \
  53.     LP0NR(0x7E, Enable, \
  54.     , EXEC_BASE_NAME)
  55.  
  56. #define Forbid() \
  57.     LP0NR(0x84, Forbid, \
  58.     , EXEC_BASE_NAME)
  59.  
  60. #define Permit() \
  61.     LP0NR(0x8A, Permit, \
  62.     , EXEC_BASE_NAME)
  63.  
  64. #define SetSR(newSR, mask) \
  65.     LP2(0x90, ULONG, SetSR, ULONG, newSR, d0, ULONG, mask, d1, \
  66.     , EXEC_BASE_NAME)
  67.  
  68. #define SuperState() \
  69.     LP0(0x96, APTR, SuperState, \
  70.     , EXEC_BASE_NAME)
  71.  
  72. #define UserState(sysStack) \
  73.     LP1NR(0x9C, UserState, APTR, sysStack, d0, \
  74.     , EXEC_BASE_NAME)
  75.  
  76. #define SetIntVector(intNumber, interrupt) \
  77.     LP2(0xA2, struct Interrupt *, SetIntVector, LONG, intNumber, d0, CONST struct Interrupt *, interrupt, a1, \
  78.     , EXEC_BASE_NAME)
  79.  
  80. #define AddIntServer(intNumber, interrupt) \
  81.     LP2NR(0xA8, AddIntServer, LONG, intNumber, d0, struct Interrupt *, interrupt, a1, \
  82.     , EXEC_BASE_NAME)
  83.  
  84. #define RemIntServer(intNumber, interrupt) \
  85.     LP2NR(0xAE, RemIntServer, LONG, intNumber, d0, struct Interrupt *, interrupt, a1, \
  86.     , EXEC_BASE_NAME)
  87.  
  88. #define Cause(interrupt) \
  89.     LP1NR(0xB4, Cause, struct Interrupt *, interrupt, a1, \
  90.     , EXEC_BASE_NAME)
  91.  
  92. #define Allocate(freeList, byteSize) \
  93.     LP2(0xBA, APTR, Allocate, struct MemHeader *, freeList, a0, ULONG, byteSize, d0, \
  94.     , EXEC_BASE_NAME)
  95.  
  96. #define Deallocate(freeList, memoryBlock, byteSize) \
  97.     LP3NR(0xC0, Deallocate, struct MemHeader *, freeList, a0, APTR, memoryBlock, a1, ULONG, byteSize, d0, \
  98.     , EXEC_BASE_NAME)
  99.  
  100. #define AllocMem(byteSize, requirements) \
  101.     LP2(0xC6, APTR, AllocMem, ULONG, byteSize, d0, ULONG, requirements, d1, \
  102.     , EXEC_BASE_NAME)
  103.  
  104. #define AllocAbs(byteSize, location) \
  105.     LP2(0xCC, APTR, AllocAbs, ULONG, byteSize, d0, APTR, location, a1, \
  106.     , EXEC_BASE_NAME)
  107.  
  108. #define FreeMem(memoryBlock, byteSize) \
  109.     LP2NR(0xD2, FreeMem, APTR, memoryBlock, a1, ULONG, byteSize, d0, \
  110.     , EXEC_BASE_NAME)
  111.  
  112. #define AvailMem(requirements) \
  113.     LP1(0xD8, ULONG, AvailMem, ULONG, requirements, d1, \
  114.     , EXEC_BASE_NAME)
  115.  
  116. #define AllocEntry(entry) \
  117.     LP1(0xDE, struct MemList *, AllocEntry, struct MemList *, entry, a0, \
  118.     , EXEC_BASE_NAME)
  119.  
  120. #define FreeEntry(entry) \
  121.     LP1NR(0xE4, FreeEntry, struct MemList *, entry, a0, \
  122.     , EXEC_BASE_NAME)
  123.  
  124. #define Insert(list, node, pred) \
  125.     LP3NR(0xEA, Insert, struct List *, list, a0, struct Node *, node, a1, struct Node *, pred, a2, \
  126.     , EXEC_BASE_NAME)
  127.  
  128. #define AddHead(list, node) \
  129.     LP2NR(0xF0, AddHead, struct List *, list, a0, struct Node *, node, a1, \
  130.     , EXEC_BASE_NAME)
  131.  
  132. #define AddTail(list, node) \
  133.     LP2NR(0xF6, AddTail, struct List *, list, a0, struct Node *, node, a1, \
  134.     , EXEC_BASE_NAME)
  135.  
  136. #define Remove(node) \
  137.     LP1NR(0xFC, Remove, struct Node *, node, a1, \
  138.     , EXEC_BASE_NAME)
  139.  
  140. #define RemHead(list) \
  141.     LP1(0x102, struct Node *, RemHead, struct List *, list, a0, \
  142.     , EXEC_BASE_NAME)
  143.  
  144. #define RemTail(list) \
  145.     LP1(0x108, struct Node *, RemTail, struct List *, list, a0, \
  146.     , EXEC_BASE_NAME)
  147.  
  148. #define Enqueue(list, node) \
  149.     LP2NR(0x10E, Enqueue, struct List *, list, a0, struct Node *, node, a1, \
  150.     , EXEC_BASE_NAME)
  151.  
  152. #define FindName(list, name) \
  153.     LP2(0x114, struct Node *, FindName, struct List *, list, a0, CONST_STRPTR, name, a1, \
  154.     , EXEC_BASE_NAME)
  155.  
  156. #define AddTask(task, initPC, finalPC) \
  157.     LP3(0x11A, APTR, AddTask, struct Task *, task, a1, CONST APTR, initPC, a2, CONST APTR, finalPC, a3, \
  158.     , EXEC_BASE_NAME)
  159.  
  160. #define RemTask(task) \
  161.     LP1NR(0x120, RemTask, struct Task *, task, a1, \
  162.     , EXEC_BASE_NAME)
  163.  
  164. #define FindTask(name) \
  165.     LP1(0x126, struct Task *, FindTask, CONST_STRPTR, name, a1, \
  166.     , EXEC_BASE_NAME)
  167.  
  168. #define SetTaskPri(task, priority) \
  169.     LP2(0x12C, BYTE, SetTaskPri, struct Task *, task, a1, LONG, priority, d0, \
  170.     , EXEC_BASE_NAME)
  171.  
  172. #define SetSignal(newSignals, signalSet) \
  173.     LP2(0x132, ULONG, SetSignal, ULONG, newSignals, d0, ULONG, signalSet, d1, \
  174.     , EXEC_BASE_NAME)
  175.  
  176. #define SetExcept(newSignals, signalSet) \
  177.     LP2(0x138, ULONG, SetExcept, ULONG, newSignals, d0, ULONG, signalSet, d1, \
  178.     , EXEC_BASE_NAME)
  179.  
  180. #define Wait(signalSet) \
  181.     LP1(0x13E, ULONG, Wait, ULONG, signalSet, d0, \
  182.     , EXEC_BASE_NAME)
  183.  
  184. #define Signal(task, signalSet) \
  185.     LP2NR(0x144, Signal, struct Task *, task, a1, ULONG, signalSet, d0, \
  186.     , EXEC_BASE_NAME)
  187.  
  188. #define AllocSignal(signalNum) \
  189.     LP1(0x14A, BYTE, AllocSignal, LONG, signalNum, d0, \
  190.     , EXEC_BASE_NAME)
  191.  
  192. #define FreeSignal(signalNum) \
  193.     LP1NR(0x150, FreeSignal, LONG, signalNum, d0, \
  194.     , EXEC_BASE_NAME)
  195.  
  196. #define AllocTrap(trapNum) \
  197.     LP1(0x156, LONG, AllocTrap, LONG, trapNum, d0, \
  198.     , EXEC_BASE_NAME)
  199.  
  200. #define FreeTrap(trapNum) \
  201.     LP1NR(0x15C, FreeTrap, LONG, trapNum, d0, \
  202.     , EXEC_BASE_NAME)
  203.  
  204. #define AddPort(port) \
  205.     LP1NR(0x162, AddPort, struct MsgPort *, port, a1, \
  206.     , EXEC_BASE_NAME)
  207.  
  208. #define RemPort(port) \
  209.     LP1NR(0x168, RemPort, struct MsgPort *, port, a1, \
  210.     , EXEC_BASE_NAME)
  211.  
  212. #define PutMsg(port, message) \
  213.     LP2NR(0x16E, PutMsg, struct MsgPort *, port, a0, struct Message *, message, a1, \
  214.     , EXEC_BASE_NAME)
  215.  
  216. #define GetMsg(port) \
  217.     LP1(0x174, struct Message *, GetMsg, struct MsgPort *, port, a0, \
  218.     , EXEC_BASE_NAME)
  219.  
  220. #define ReplyMsg(message) \
  221.     LP1NR(0x17A, ReplyMsg, struct Message *, message, a1, \
  222.     , EXEC_BASE_NAME)
  223.  
  224. #define WaitPort(port) \
  225.     LP1(0x180, struct Message *, WaitPort, struct MsgPort *, port, a0, \
  226.     , EXEC_BASE_NAME)
  227.  
  228. #define FindPort(name) \
  229.     LP1(0x186, struct MsgPort *, FindPort, CONST_STRPTR, name, a1, \
  230.     , EXEC_BASE_NAME)
  231.  
  232. #define AddLibrary(library) \
  233.     LP1NR(0x18C, AddLibrary, struct Library *, library, a1, \
  234.     , EXEC_BASE_NAME)
  235.  
  236. #define RemLibrary(library) \
  237.     LP1NR(0x192, RemLibrary, struct Library *, library, a1, \
  238.     , EXEC_BASE_NAME)
  239.  
  240. #define OldOpenLibrary(libName) \
  241.     LP1(0x198, struct Library *, OldOpenLibrary, CONST_STRPTR, libName, a1, \
  242.     , EXEC_BASE_NAME)
  243.  
  244. #define CloseLibrary(library) \
  245.     LP1NR(0x19E, CloseLibrary, struct Library *, library, a1, \
  246.     , EXEC_BASE_NAME)
  247.  
  248. #define SetFunction(library, funcOffset, newFunction) \
  249.     LP3FP(0x1A4, APTR, SetFunction, struct Library *, library, a1, LONG, funcOffset, a0, __fpt, newFunction, d0, \
  250.     , EXEC_BASE_NAME, ULONG (*__fpt)())
  251.  
  252. #define SumLibrary(library) \
  253.     LP1NR(0x1AA, SumLibrary, struct Library *, library, a1, \
  254.     , EXEC_BASE_NAME)
  255.  
  256. #define AddDevice(device) \
  257.     LP1NR(0x1B0, AddDevice, struct Device *, device, a1, \
  258.     , EXEC_BASE_NAME)
  259.  
  260. #define RemDevice(device) \
  261.     LP1NR(0x1B6, RemDevice, struct Device *, device, a1, \
  262.     , EXEC_BASE_NAME)
  263.  
  264. #define OpenDevice(devName, unit, ioRequest, flags) \
  265.     LP4(0x1BC, BYTE, OpenDevice, CONST_STRPTR, devName, a0, ULONG, unit, d0, struct IORequest *, ioRequest, a1, ULONG, flags, d1, \
  266.     , EXEC_BASE_NAME)
  267.  
  268. #define CloseDevice(ioRequest) \
  269.     LP1NR(0x1C2, CloseDevice, struct IORequest *, ioRequest, a1, \
  270.     , EXEC_BASE_NAME)
  271.  
  272. #define DoIO(ioRequest) \
  273.     LP1(0x1C8, BYTE, DoIO, struct IORequest *, ioRequest, a1, \
  274.     , EXEC_BASE_NAME)
  275.  
  276. #define SendIO(ioRequest) \
  277.     LP1NR(0x1CE, SendIO, struct IORequest *, ioRequest, a1, \
  278.     , EXEC_BASE_NAME)
  279.  
  280. #define CheckIO(ioRequest) \
  281.     LP1(0x1D4, struct IORequest *, CheckIO, struct IORequest *, ioRequest, a1, \
  282.     , EXEC_BASE_NAME)
  283.  
  284. #define WaitIO(ioRequest) \
  285.     LP1(0x1DA, BYTE, WaitIO, struct IORequest *, ioRequest, a1, \
  286.     , EXEC_BASE_NAME)
  287.  
  288. #define AbortIO(ioRequest) \
  289.     LP1NR(0x1E0, AbortIO, struct IORequest *, ioRequest, a1, \
  290.     , EXEC_BASE_NAME)
  291.  
  292. #define AddResource(resource) \
  293.     LP1NR(0x1E6, AddResource, APTR, resource, a1, \
  294.     , EXEC_BASE_NAME)
  295.  
  296. #define RemResource(resource) \
  297.     LP1NR(0x1EC, RemResource, APTR, resource, a1, \
  298.     , EXEC_BASE_NAME)
  299.  
  300. #define OpenResource(resName) \
  301.     LP1(0x1F2, APTR, OpenResource, CONST_STRPTR, resName, a1, \
  302.     , EXEC_BASE_NAME)
  303.  
  304. #define RawDoFmt(formatString, dataStream, putChProc, putChData) \
  305.     LP4FP(0x20A, APTR, RawDoFmt, CONST_STRPTR, formatString, a0, CONST APTR, dataStream, a1, __fpt, putChProc, a2, APTR, putChData, a3, \
  306.     , EXEC_BASE_NAME, VOID (*__fpt)())
  307.  
  308. #define GetCC() \
  309.     LP0(0x210, ULONG, GetCC, \
  310.     , EXEC_BASE_NAME)
  311.  
  312. #define TypeOfMem(address) \
  313.     LP1(0x216, ULONG, TypeOfMem, CONST APTR, address, a1, \
  314.     , EXEC_BASE_NAME)
  315.  
  316. #define Procure(sigSem, bidMsg) \
  317.     LP2(0x21C, ULONG, Procure, struct SignalSemaphore *, sigSem, a0, struct SemaphoreMessage *, bidMsg, a1, \
  318.     , EXEC_BASE_NAME)
  319.  
  320. #define Vacate(sigSem, bidMsg) \
  321.     LP2NR(0x222, Vacate, struct SignalSemaphore *, sigSem, a0, struct SemaphoreMessage *, bidMsg, a1, \
  322.     , EXEC_BASE_NAME)
  323.  
  324. #define OpenLibrary(libName, version) \
  325.     LP2(0x228, struct Library *, OpenLibrary, CONST_STRPTR, libName, a1, ULONG, version, d0, \
  326.     , EXEC_BASE_NAME)
  327.  
  328. #define InitSemaphore(sigSem) \
  329.     LP1NR(0x22E, InitSemaphore, struct SignalSemaphore *, sigSem, a0, \
  330.     , EXEC_BASE_NAME)
  331.  
  332. #define ObtainSemaphore(sigSem) \
  333.     LP1NR(0x234, ObtainSemaphore, struct SignalSemaphore *, sigSem, a0, \
  334.     , EXEC_BASE_NAME)
  335.  
  336. #define ReleaseSemaphore(sigSem) \
  337.     LP1NR(0x23A, ReleaseSemaphore, struct SignalSemaphore *, sigSem, a0, \
  338.     , EXEC_BASE_NAME)
  339.  
  340. #define AttemptSemaphore(sigSem) \
  341.     LP1(0x240, ULONG, AttemptSemaphore, struct SignalSemaphore *, sigSem, a0, \
  342.     , EXEC_BASE_NAME)
  343.  
  344. #define ObtainSemaphoreList(sigSem) \
  345.     LP1NR(0x246, ObtainSemaphoreList, struct List *, sigSem, a0, \
  346.     , EXEC_BASE_NAME)
  347.  
  348. #define ReleaseSemaphoreList(sigSem) \
  349.     LP1NR(0x24C, ReleaseSemaphoreList, struct List *, sigSem, a0, \
  350.     , EXEC_BASE_NAME)
  351.  
  352. #define FindSemaphore(name) \
  353.     LP1(0x252, struct SignalSemaphore *, FindSemaphore, STRPTR, name, a1, \
  354.     , EXEC_BASE_NAME)
  355.  
  356. #define AddSemaphore(sigSem) \
  357.     LP1NR(0x258, AddSemaphore, struct SignalSemaphore *, sigSem, a1, \
  358.     , EXEC_BASE_NAME)
  359.  
  360. #define RemSemaphore(sigSem) \
  361.     LP1NR(0x25E, RemSemaphore, struct SignalSemaphore *, sigSem, a1, \
  362.     , EXEC_BASE_NAME)
  363.  
  364. #define SumKickData() \
  365.     LP0(0x264, ULONG, SumKickData, \
  366.     , EXEC_BASE_NAME)
  367.  
  368. #define AddMemList(size, attributes, pri, base, name) \
  369.     LP5NR(0x26A, AddMemList, ULONG, size, d0, ULONG, attributes, d1, LONG, pri, d2, APTR, base, a0, CONST_STRPTR, name, a1, \
  370.     , EXEC_BASE_NAME)
  371.  
  372. #define CopyMem(source, dest, size) \
  373.     LP3NR(0x270, CopyMem, CONST APTR, source, a0, APTR, dest, a1, ULONG, size, d0, \
  374.     , EXEC_BASE_NAME)
  375.  
  376. #define CopyMemQuick(source, dest, size) \
  377.     LP3NR(0x276, CopyMemQuick, CONST APTR, source, a0, APTR, dest, a1, ULONG, size, d0, \
  378.     , EXEC_BASE_NAME)
  379.  
  380. #define CacheClearU() \
  381.     LP0NR(0x27C, CacheClearU, \
  382.     , EXEC_BASE_NAME)
  383.  
  384. #define CacheClearE(address, length, caches) \
  385.     LP3NR(0x282, CacheClearE, APTR, address, a0, ULONG, length, d0, ULONG, caches, d1, \
  386.     , EXEC_BASE_NAME)
  387.  
  388. #define CacheControl(cacheBits, cacheMask) \
  389.     LP2(0x288, ULONG, CacheControl, ULONG, cacheBits, d0, ULONG, cacheMask, d1, \
  390.     , EXEC_BASE_NAME)
  391.  
  392. #define CreateIORequest(port, size) \
  393.     LP2(0x28E, APTR, CreateIORequest, CONST struct MsgPort *, port, a0, ULONG, size, d0, \
  394.     , EXEC_BASE_NAME)
  395.  
  396. #define DeleteIORequest(iorequest) \
  397.     LP1NR(0x294, DeleteIORequest, APTR, iorequest, a0, \
  398.     , EXEC_BASE_NAME)
  399.  
  400. #define CreateMsgPort() \
  401.     LP0(0x29A, struct MsgPort *, CreateMsgPort, \
  402.     , EXEC_BASE_NAME)
  403.  
  404. #define DeleteMsgPort(port) \
  405.     LP1NR(0x2A0, DeleteMsgPort, struct MsgPort *, port, a0, \
  406.     , EXEC_BASE_NAME)
  407.  
  408. #define ObtainSemaphoreShared(sigSem) \
  409.     LP1NR(0x2A6, ObtainSemaphoreShared, struct SignalSemaphore *, sigSem, a0, \
  410.     , EXEC_BASE_NAME)
  411.  
  412. #define AllocVec(byteSize, requirements) \
  413.     LP2(0x2AC, APTR, AllocVec, ULONG, byteSize, d0, ULONG, requirements, d1, \
  414.     , EXEC_BASE_NAME)
  415.  
  416. #define FreeVec(memoryBlock) \
  417.     LP1NR(0x2B2, FreeVec, APTR, memoryBlock, a1, \
  418.     , EXEC_BASE_NAME)
  419.  
  420. #define CreatePool(requirements, puddleSize, threshSize) \
  421.     LP3(0x2B8, APTR, CreatePool, ULONG, requirements, d0, ULONG, puddleSize, d1, ULONG, threshSize, d2, \
  422.     , EXEC_BASE_NAME)
  423.  
  424. #define DeletePool(poolHeader) \
  425.     LP1NR(0x2BE, DeletePool, APTR, poolHeader, a0, \
  426.     , EXEC_BASE_NAME)
  427.  
  428. #define AllocPooled(poolHeader, memSize) \
  429.     LP2(0x2C4, APTR, AllocPooled, APTR, poolHeader, a0, ULONG, memSize, d0, \
  430.     , EXEC_BASE_NAME)
  431.  
  432. #define FreePooled(poolHeader, memory, memSize) \
  433.     LP3NR(0x2CA, FreePooled, APTR, poolHeader, a0, APTR, memory, a1, ULONG, memSize, d0, \
  434.     , EXEC_BASE_NAME)
  435.  
  436. #define AttemptSemaphoreShared(sigSem) \
  437.     LP1(0x2D0, ULONG, AttemptSemaphoreShared, struct SignalSemaphore *, sigSem, a0, \
  438.     , EXEC_BASE_NAME)
  439.  
  440. #define ColdReboot() \
  441.     LP0NR(0x2D6, ColdReboot, \
  442.     , EXEC_BASE_NAME)
  443.  
  444. #define StackSwap(newStack) \
  445.     LP1NR(0x2DC, StackSwap, struct StackSwapStruct *, newStack, a0, \
  446.     , EXEC_BASE_NAME)
  447.  
  448. #define ChildFree(tid) \
  449.     LP1NR(0x2E2, ChildFree, APTR, tid, d0, \
  450.     , EXEC_BASE_NAME)
  451.  
  452. #define ChildOrphan(tid) \
  453.     LP1NR(0x2E8, ChildOrphan, APTR, tid, d0, \
  454.     , EXEC_BASE_NAME)
  455.  
  456. #define ChildStatus(tid) \
  457.     LP1NR(0x2EE, ChildStatus, APTR, tid, d0, \
  458.     , EXEC_BASE_NAME)
  459.  
  460. #define ChildWait(tid) \
  461.     LP1NR(0x2F4, ChildWait, APTR, tid, d0, \
  462.     , EXEC_BASE_NAME)
  463.  
  464. #define CachePreDMA(address, length, flags) \
  465.     LP3(0x2FA, APTR, CachePreDMA, CONST APTR, address, a0, ULONG *, length, a1, ULONG, flags, d0, \
  466.     , EXEC_BASE_NAME)
  467.  
  468. #define CachePostDMA(address, length, flags) \
  469.     LP3NR(0x300, CachePostDMA, CONST APTR, address, a0, ULONG *, length, a1, ULONG, flags, d0, \
  470.     , EXEC_BASE_NAME)
  471.  
  472. #define AddMemHandler(memhand) \
  473.     LP1NR(0x306, AddMemHandler, struct Interrupt *, memhand, a1, \
  474.     , EXEC_BASE_NAME)
  475.  
  476. #define RemMemHandler(memhand) \
  477.     LP1NR(0x30C, RemMemHandler, struct Interrupt *, memhand, a1, \
  478.     , EXEC_BASE_NAME)
  479.  
  480. #define ObtainQuickVector(interruptCode) \
  481.     LP1(0x312, ULONG, ObtainQuickVector, APTR, interruptCode, a0, \
  482.     , EXEC_BASE_NAME)
  483.  
  484. #endif /*  _INLINE_EXEC_H  */
  485.